Section1: Introduction¶
About Us:¶
The three of us are huge cricket fans. We come from India and cricket is not just a game there, it's a religion. When we got to know that we need to do a project using Python, all of us instantly connected with the topic and were amazed by the idea of making this team project a fun project. There are a couple of reasons that come to our minds when we think about the project’s importance. First, how cool would it be if we could actually predict the outcomes of cricket matches and see if a team is able to win against all odds. Second, this will be helpful for the advertisement industry who rely heavily on the game results to achieve the desired results from their marketing campaigns.
About the Project¶
Four years is a long time for a team to go from zero to hero. This is exactly what happened with current World Cup champions England. England, in the 2015 World Cup, got eliminated in the group stages, however come 2019, they were crowned champions of the world in their own backyard.
- In this project, we would analyze and plot the journey of teams that participated in the 2019 Cricket World Cup by using all the data we collected from the 'espncricinfo' website. We would try to understand and analyse which team would have been the ideal team to place bets on in the ICC 2019 Cricket World Cup.
We wish to analyse the data and draw various conclusions based on different types of data visualizations to help us understand how a particular team/player performs under certain conditions. The conditions include; the venue of the tournament, that is, whether they are playing at home or away from home, what kind of pitches they are playing on and how many tosses the team wins or loses. We would also take into consideration the number of matches a team has won at chasing or defending a total.
Questions of Interest
- Which team had the best chance of winning the World Cup - 2019(based on the model)?
- Who were the best bowlers and batsmen?
Basics About Cricket¶
During the Project showcase, we realised that not many of our classmates watched Cricket so we thought to mention some fundamental concepts/rules about cricket that would help them understand the project better.¶
- Two teams (11 players each) face each other in a 50 overs game of Cricket. Each team gets to bat for 50 overs.
- The side that wins the Toss, elects to Bat/Bowl first
- The aim of the team Batting first is to score as many runs as possible in those 50 overs (that is 300 balls, each over has 6 balls) so that the team bating second cannot beat that score.
- The aim of the bowling team is to restrict the batting team to the least possible score. This can be done by taking regular wickets and mantaining good bowling statistics.
Wickets: The batting team has 10 wickets in hand. That is 10 players get to bat from each team.
Also refer to 'https://www.youtube.com/watch?v=g-beFHld19c'. This is a link to a short YouTube video that explains the game of Cricket in just 3.5 Minutes.
Section2: Data Acquisition and Cleaning Code¶
We have used web scraping to collect data from stats.espncricinfo.com, which has all the data of the past cricket matches and players. We scraped data for the past six years and saved it into multiple csv files. We required data of only the top ten teams that played the World Cup, but the website had the data for all the teams that play cricket. To clean the data and get the data for only the desired ten teams, we first removed the data of other unwanted teams. Second, the World Cup was played in England so we filtered the data for all the matches played only in England. Also, we merged the data from six different years (2014 to 2019), six different files into one CSV file becuse the file structure was same and we could now work on one file and get the stats for all the different years by indexing just one file. We also gathered information about the grounds in England where the 2019 World Cup was played and also the batsmen and the bowlers' data who played the world cup.
The code below shows the process of scraping. The files were scraped from the website and directly stored as CSV files on the local system
In [1]:
from bs4 import BeautifulSoup
import requests
from numpy import nan as NA
import numpy as np
import pandas as pd
url = 'http://stats.espncricinfo.com/ci/engine/records/team/series_results.html?class=2;id=201;type=decade'
page = requests.get(url)
readPandas = pd.read_html(url, match ='Winner' )[0]
readPandas.to_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ SeriesResults.csv')
In [2]:
url = 'http://stats.espncricinfo.com/ci/engine/records/team/results_summary.html?class=2;id=201;type=decade'
page = requests.get(url)
readPandas = pd.read_html(url, match ='Team' )[0]
readPandas.to_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ MatchResults.csv')
In [3]:
url = 'http://stats.espncricinfo.com/ci/engine/records/team/match_results.html?class=2;id=2015;type=year'
page = requests.get(url)
readPandas = pd.read_html(url, match ='Team 1' )[0]
readPandas.to_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ Results2015.csv')
In [4]:
url = 'http://stats.espncricinfo.com/ci/engine/records/team/match_results.html?class=2;id=2016;type=year'
page = requests.get(url)
readPandas = pd.read_html(url, match ='Team 1' )[0]
readPandas.to_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ Results2016.csv')
In [5]:
url = 'http://stats.espncricinfo.com/ci/engine/records/team/match_results.html?class=2;id=2017;type=year'
page = requests.get(url)
readPandas = pd.read_html(url, match ='Team 1' )[0]
readPandas.to_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ Results2017.csv')
In [6]:
url = 'http://stats.espncricinfo.com/ci/engine/records/team/match_results.html?class=2;id=2018;type=year'
page = requests.get(url)
readPandas = pd.read_html(url, match ='Team 1' )[0]
readPandas.to_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ Results2018.csv')
In [7]:
url = 'http://stats.espncricinfo.com/ci/engine/records/team/match_results.html?class=2;id=2019;type=year'
page = requests.get(url)
readPandas = pd.read_html(url, match ='Team 1' )[0]
readPandas.to_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ Results2019.csv')
In [8]:
url = 'http://stats.espncricinfo.com/ci/engine/records/team/highest_innings_totals.html?class=2;id=201;type=decade'
page = requests.get(url)
readPandas = pd.read_html(url, match ='Team' )[0]
readPandas.to_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ HighestTotals.csv')
In [9]:
url = 'http://stats.espncricinfo.com/ci/engine/records/team/lowest_innings_totals.html?class=2;id=201;type=decade'
page = requests.get(url)
readPandas = pd.read_html(url, match ='Team' )[0]
readPandas.to_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ LowestTotals.csv')
In [10]:
url = 'http://stats.espncricinfo.com/ci/engine/records/fielding/most_catches_career.html?class=2;id=201;type=decade'
page = requests.get(url)
readPandas = pd.read_html(url, match ='Player' )[0]
readPandas.to_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ MostCatches.csv')
In [11]:
url = 'http://stats.espncricinfo.com/ci/engine/stats/index.html?class=2;spanmax2=12+Dec+2019;spanmin2=12+Dec+2012;spanval2=span;template=results;type=aggregate;view=ground'
page = requests.get(url)
readPandas = pd.read_html(url, match ='Mat' )[0]
readPandas.to_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ GroundNumbers.csv')
In [12]:
url = 'http://stats.espncricinfo.com/ci/content/records/283878.html'
page = requests.get(url)
readPandas = pd.read_html(url, match ='Mat' )[0]
readPandas.to_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/Match_Results.csv')
Extracting top 50 totals by a team¶
In [13]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
In [14]:
import pandas as pd
highest_totals = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ HighestTotals.csv')
In [15]:
# Highest 50 totals made by any team in ODI
highest_totals
Out[15]:
In [16]:
# displaying teams that have scored these highest totals
highest_total_country = highest_totals.groupby('Team').count()['Score']
highest_total_country
Out[16]:
Creating a dataframe of results of ODI matches of the years 2015, 2016, 2017, 2018 and 2019¶
In [17]:
# importing the Results dataset of different years
Results_2015 = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ Results2015.csv')
Results_2016 = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ Results2016.csv')
Results_2017 = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ Results2017.csv')
Results_2018 = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ Results2018.csv')
Results_2019 = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ Results2019.csv')
In [18]:
# concating these dataframes
Results = pd.concat([Results_2015, Results_2016, Results_2017, Results_2018, Results_2019])
In [19]:
Results.drop(["Unnamed: 0"], axis = 1, inplace = True)
In [20]:
Results.reset_index()
Out[20]:
--> We merged five different results file from five different years into one to make one consoliated dataframe. This was done so that it would become easier to access all the results at once and we would not have to refer back and forth to access the results from different years.
We removed the data of the teams which were not playing the World Cup from the dataframe¶
In [21]:
# Get names of indexes for which column is not in given 10 teams
indexNames = Results[ (Results['Team 1'] != 'India') & (Results['Team 1'] != 'England') & (Results['Team 1'] != 'Pakistan') & (Results['Team 1'] != 'Sri Lanka') & (Results['Team 1'] != 'Australia') & (Results['Team 1'] != 'South Africa') & (Results['Team 1'] != 'New Zealand') & (Results['Team 1'] != 'Bangladesh') & (Results['Team 1'] != 'Afghanistan') & (Results['Team 1'] != 'West Indies') ].index
# Delete these row indexes from dataFrame
Results.drop(indexNames , inplace=True)
In [22]:
# Get names of indexes for which column is not in given 10 teams
indexNames = Results[ (Results['Team 2'] != 'India') & (Results['Team 2'] != 'England') & (Results['Team 2'] != 'Pakistan') & (Results['Team 2'] != 'Sri Lanka') & (Results['Team 2'] != 'Australia') & (Results['Team 2'] != 'South Africa') & (Results['Team 2'] != 'New Zealand') & (Results['Team 2'] != 'Bangladesh') & (Results['Team 2'] != 'Afghanistan') & (Results['Team 2'] != 'West Indies') ].index
# Delete these row indexes from dataFrame
Results.drop(indexNames , inplace=True)
In [23]:
Results
Out[23]:
Above, we have the final dataframe with the results of all the teams that played in the world cup. These are essentially the top 10 teams that qualified fo the World Cup based on ICC (International Cricket Council)data. The International Cricket Council is the global governing body of cricket and conducts international matches
In [24]:
# Getting the teams with each of their number of wins
Results_winner = Results.groupby('Winner').count()['Ground']
Results_winner
Out[24]:
--> The above stats show us that England has won most number of matches played at home. This makes them the favourites for the World Cup because the World Cup is to be played in England.¶
- Looking at just the numbers of victories at home cannot be the deciding factor. Let's gather some more insights about the grounds in England where the World Cup was held.
Extracting the Ground information and then extracting the information about the grounds in England where the World Cup was played¶
In [25]:
ground_averages = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/Ground_Averages.csv')
ground_averages.head()
Out[25]:
Above dataframe contains the basic information about the grounds like:
- Total matches played
- Time period of when these matches were played
- Total runs scored and total wickets that fell and so on.
In [26]:
# Defining the grounds of England
World_Cup_Grounds=["Lord's, London - England", "The Rose Bowl, Southampton - England", "Trent Bridge, Nottingham - England", "Sophia Gardens, Cardiff - England", "Kennington Oval, London - England", "Edgbaston, Birmingham - England", "Old Trafford, Manchester - England", "Riverside Ground, Chester-le-Street - England", "Headingley, Leeds - England", "County Ground, Bristol - England", "County Ground, Taunton - England"]
In [27]:
World_Cup_Grounds
Out[27]:
In [28]:
Worldcup_Ground_Stats = []
England_Grounds = ground_averages.Ground
for grounds in England_Grounds:
for venues in World_Cup_Grounds :
if grounds in venues:
Worldcup_Ground_Stats.append((venues))
In [29]:
Worldcup_Ground_Stats
Out[29]:
--> The above function helps us to filter out only those grounds where the World Cup was played. As our earlier dataframe contained all the grounds' information, there was some irrelevant data.¶
We see here that we do not have data for "County Ground, Taunton - England" in "ground_averages" dataframe so we do not include that in our analysis.¶
In [30]:
WorldCup_Grounds_Stats = ground_averages[ground_averages.Ground.isin([Ground for Ground in Worldcup_Ground_Stats])]
In [31]:
WorldCup_Grounds_Stats
Out[31]:
The above mentioned grounds in the dataframe are the venues that hosted the ICC Cricket World Cup 2019 matches apart from "County Ground, Taunton - England"¶
Extracting match results table¶
In [32]:
match_results = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/Match_Results.csv')
match_results.head()
Out[32]:
In [33]:
# Get names of indexes for which column is not in given 10 teams
match_results.rename(columns = {'Country':'Team'}, inplace = True)
indexNames = match_results[ (match_results['Team'] != 'India') & (match_results['Team'] != 'England') & (match_results['Team'] != 'Pakistan') & (match_results['Team'] != 'Sri Lanka') & (match_results['Team'] != 'Australia') & (match_results['Team'] != 'South Africa') & (match_results['Team'] != 'New Zealand') & (match_results['Team'] != 'Bangladesh') & (match_results['Team'] != 'Afghanistan') & (match_results['Team'] != 'West Indies') ].index
# Delete these row indexes from dataFrame
match_results.drop(indexNames , inplace=True)
In [34]:
match_results
Out[34]:
The data above represents the Top 10 teams of interest and their corresponding match stats like win, Lost, and tied number¶
In [35]:
# creating a win perentage column as number of matches played by different teams is different
match_results['Win Percent'] = (match_results['Won']/match_results['Mat'])*100
match_results
Out[35]:
Section3: Visualizations¶
Grounds Data Analysis¶
In [36]:
import matplotlib
# ax = match_results.plot.bar(x='Team', y='Win Percent')
sns.barplot(x = "Team", y = "Win Percent", data = match_results).set_title("Win Percent of each Country")
plt.xlabel("Team")
plt.ylabel("Win Percent")
plt.xticks(rotation = 90)
Out[36]:
Fig1.¶
--> We can observe from above graph,¶
- That in previous matches, the win percentage of South Africa is maximum, followed by Australia and Pakistan.
- This means that South Africa is a strong team and wins most of its matches. Australia is the second best team followed by Pakistan. England is not among the top three teams based on Win Percentage. Neither is India.
- From the above graph, it would not be wrong to say that South Africa will win the cup. However, lets analyse a little more.
In [37]:
ODI_Scores_Data = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ODI_Match_Results.csv')
In [38]:
WC_venue_pitches = ["The Oval, London","Trent Bridge, Nottingham","Sophia Gardens, Cardiff","County Ground, Bristol","Rose Bowl, Southampton","County Ground, Taunton","Old Trafford, Manchester","Edgbaston, Birmingham","Headingley, Leeds","Lord's, London","Riverside Ground, Chester-le-Street"]
In [39]:
#Total Grounds
WC_Ground_Stats = []
ODI_Grounds = ODI_Scores_Data.Ground
for i in ODI_Grounds:
for j in WC_venue_pitches:
if i in j:
WC_Ground_Stats.append((i,j))
In [40]:
Ground_names = dict(set(WC_Ground_Stats))
def Full_Ground_names(value):
return Ground_names[value]
Ground_names
Out[40]:
In [41]:
#Let's gather the data of all ODI's in these WC Venues
WC_England_History = ODI_Scores_Data[ODI_Scores_Data.Ground.isin([Ground[0] for Ground in WC_Ground_Stats])]
WC_England_History["Ground"] = WC_England_History.Ground.apply(Full_Ground_names)
WC_England_History.head()
Out[41]:
In [42]:
winnings = WC_England_History[["Country","Result"]]
winnings["count"] = 1
Ground_Results_Per_Team = winnings.groupby(["Country","Result"]).aggregate(["sum"])
Ground_Results_Per_Team = Ground_Results_Per_Team.groupby(level=0).apply(lambda x:100 * x / float(x.sum())).reset_index()
Ground_Results_Per_Team.columns = ["Country","Result","Count"]
Ground_Results_Per_Team.head()
Out[42]:
In [43]:
import plotly.graph_objects as go
fig = go.Figure(data=[
go.Bar(name='aban', x=Ground_Results_Per_Team[Ground_Results_Per_Team.Result == 'abandoned'].Country, y=Ground_Results_Per_Team[Ground_Results_Per_Team.Result == 'aban'].Count),
go.Bar(name='lost', x=Ground_Results_Per_Team[Ground_Results_Per_Team.Result == 'lost'].Country, y=Ground_Results_Per_Team[Ground_Results_Per_Team.Result == 'lost'].Count),
go.Bar(name='n/r', x=Ground_Results_Per_Team[Ground_Results_Per_Team.Result == 'n/r'].Country, y=Ground_Results_Per_Team[Ground_Results_Per_Team.Result == 'n/r'].Count),
go.Bar(name='won', x=Ground_Results_Per_Team[Ground_Results_Per_Team.Result == 'won'].Country, y=Ground_Results_Per_Team[Ground_Results_Per_Team.Result == 'won'].Count),
go.Bar(name='-', x=Ground_Results_Per_Team[Ground_Results_Per_Team.Result == '-'].Country, y=Ground_Results_Per_Team[Ground_Results_Per_Team.Result == '-'].Count),
go.Bar(name='tied', x=Ground_Results_Per_Team[Ground_Results_Per_Team.Result == 'tied'].Country, y=Ground_Results_Per_Team[Ground_Results_Per_Team.Result == 'tied'].Count),
])
# Change the bar mode
fig.update_layout(barmode='group', title = 'Details of Matches - Country Wise',xaxis_title="Country",yaxis_title="Count Of Matches",)
fig.show()
Fig 2¶
--> The above interactive graph shows the comparision of the number of matches each team has lost,won, tied. It also represents the number of matches that were abandoned or had no result.¶
- This gives us a clear comparison among various teams and their performances in England.
- This graph tells us that after India, England has the highest number of matches won. This is different from the result shown in Fig1. This is because, Fig2 shows the data for only those matches that were played in England. Clearly we can see that England performs better on its home grounds. (Home Advantage)
- This also gives us the answer to one of our questions: If home gorund affects the performance of a team or not? Yes it does.
--> South Africa is not shown in good light here. They have lost more matches than they have won in England. This is in contrast to the results we saw in the previous graph, Fig1. Hence, we can say that now England and India are major contenders of the World Cup.¶
Now lets see and analyse if its advantageous to Bat first or Bowl first¶
In [44]:
Inning_Wins = WC_England_History[WC_England_History.Result == "won"].Bat.value_counts(normalize = True).reset_index()
sns.barplot(x = "index", y = "Bat", data = Inning_Wins).set_title("Wins by Innings")
plt.xlabel("Innings")
plt.ylabel("Win Percentage")
Out[44]:
Fig 3.¶
--> Fig3 shows that the team that bats 2nd win more matches than the teams that bats 1st.¶
- This means that the teams chasing have a better chance of winning the match. This may be due to the fact that the team batting second already knows the target and they can devise a strategy to achieve that score efficiently. Also they have watched the team batting first and know how the pitch is going to behave.
- Also, the team batting first does not know much about the condition the pitch is in, as they are the first team to bat. It might take them some 'overs/balls' to figure out the optimum hitting strategy. Whether to hit boundaries or keep taking sngles. Whether the pitch is damp or dry? How the ball is going to bounce and swing on the pitch?
Note: When one team bats and other bowls, it is termed as an innings. after 50 overs, the teams exchange roles and the second team now bats and first one bowls. This is now called second innings.
In [45]:
Pitch_Innings = WC_England_History[WC_England_History.Result == "won"][["Bat","Ground"]]
Pitch_Innings["Count"] = 1
Pitch_Innings = Pitch_Innings.groupby(["Ground","Bat"]).sum()
Pitch_Innings = Pitch_Innings.groupby(level=0).apply(lambda x:100 * x / float(x.sum())).reset_index()
Pitch_Innings.columns = ["Ground", "Bat","Wins"]
Pitch_Innings.head( 5 )
Out[45]:
In [46]:
plt.figure(figsize=(15,8))
g = sns.lineplot( x = "Ground", y = "Wins", hue = "Bat", style="Bat", markers=True, data = Pitch_Innings)
plt.xticks(rotation = 60)
plt.title('Win - Batting 1st or 2nd')
Out[46]:
Fig 4¶
--> The above graph shows,¶
- that in specific grounds, the team that bats first wins more number of time and at other venues, the team batting second wins more matches. For example, at County Ground, Bristol, the team batting second is expected to win the match based on the past trend and at Lord's, the team batting first often wind the match.
- This supports the findings in Fig3. On most of the grounds, the team batting second wins.
Now we will analyse the effect of winning or losing the toss on match results¶
In [47]:
Inning_Wins = WC_England_History[WC_England_History.Result == "won"].Toss.value_counts(normalize = True).reset_index()
sns.barplot(x = "index", y = "Toss", data = Inning_Wins).set_title("Wins by Toss")
plt.xlabel("Toss")
plt.ylabel("Win Percentage")
Out[47]:
Fig 5a.¶
--> The above graph shows a surprising finding.¶
- Usually it is said that Toss is one of the most important factors that decides the outcome of the game. People believe that if a team wins the toss, there is a high chance that it wins the match as it gets to choose whether to bat first or bowl first.
- But from the graph above, we see that the team losing the toss wins more matches. This is in contradiction to the usual belief.
- This means that on the grounds in England, Toss really doesn't matter. There are other important factors that govern the result of the game.
In [48]:
Pitch_Innings = WC_England_History[WC_England_History.Result == "won"][["Toss","Ground"]]
Pitch_Innings["Count"] = 1
Pitch_Innings = Pitch_Innings.groupby(["Ground","Toss"]).sum()
Pitch_Innings = Pitch_Innings.groupby(level=0).apply(lambda x:100 * x / float(x.sum())).reset_index()
Pitch_Innings.columns = ["Ground", "Toss","Wins"]
Pitch_Innings.head( 5 )
Out[48]:
In [49]:
plt.figure(figsize=(15,8))
sns.barplot(x = "Ground", y = "Wins", hue = "Toss", data = Pitch_Innings).set_title("Results - Based on Toss")
plt.xticks(rotation = 60)
Out[49]:
Fig 5b.¶
--> This is a continuation of Fig 5a.¶
- Here we see that 6/10 grounds favour the teams that don't win the toss.
- Only at 'Oval' and 'Trent Bridge', the team winning the toss wind the match.
- If anyone of us were a Captain of a team, we would like to loose the toss at these grounds as it would mean that we have higher possibility of winning the match.
Lets see the distribution of scores in different grounds of England¶
In [50]:
ODI_Scores = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ODI_Match_Totals.csv')
In [51]:
#Let's gather the data of all ODI's in these WC Venues
WC_England_Scores = ODI_Scores[ODI_Scores.Ground.isin([Ground[0] for Ground in WC_Ground_Stats])]
WC_England_Scores["Ground"] = WC_England_Scores.Ground.apply(Full_Ground_names)
WC_England_Scores.head()
Out[51]:
In [52]:
WC_England_Scores = WC_England_Scores[~WC_England_Scores.Score.str.contains("D")]
In [53]:
Scores = [int(item[0]) for item in WC_England_Scores.Score.str.split("/")]
WC_England_Scores["Score_without_wickets"] = Scores
Stadium_Scores = WC_England_Scores[["Score_without_wickets","Ground"]]
Stadium_Scores = Stadium_Scores[Stadium_Scores.Score_without_wickets > 50]
plt.figure(figsize=(12,6))
plt.xticks(rotation = 60)
sns.violinplot(x = "Ground", y = "Score_without_wickets",data = Stadium_Scores).set_title("Scores vs Pitches")
plt.ylabel("Scores")
Out[53]:
Fig 6.¶
--> The above plot tells us about distribution of scores on different grounds.¶
- The white dot in the middle gives us the Mean of the scores.
- The length and the area under the graph, gives us the Standard Deviation of the scores.
- We can say that at Rose Bowl, Headlingley and Lord's, the scores are quite consistent and there is not much deviations in scores.
- But, at The Oval, Old Trafford, Edgbaston and County, the range of scores is very high and thus prediction of scores is difficult.
- This would mean that, at Lords, a score of 250 runs or above would be hard to chase down and hence the chances of victory for the team with that score are high.
Lets find out, at what ground which team has won the maximum number of times¶
In [54]:
Grounds = WC_England_Scores.Ground.unique()
WC_Teams = WC_England_Scores.Country.unique()
Ground_Winnings = {}
for Ground in Grounds:
Ground_Winnings.update({Ground : {}})
for Team in WC_Teams:
Country_Ground_Record = WC_England_Scores[(WC_England_Scores.Country == Team) & \
(WC_England_Scores.Ground == Ground)]
matches_played = len(Country_Ground_Record)
if matches_played == 0:
continue
matches_won = len(Country_Ground_Record[Country_Ground_Record.Result == "won"])
winning_percentage = matches_won / matches_played * 100
Ground_Winnings[Ground].update({Team : {"matches_played" : matches_played,\
"matches_won": matches_won,\
"winning_percentage" : winning_percentage}})
In [55]:
Data_Frame_Data = []
for Pitch, P_Data in Ground_Winnings.items():
for Team, Team_Data in P_Data.items():
inside = []
inside.extend([Pitch,Team,Team_Data["matches_played"],\
Team_Data["matches_won"],Team_Data["winning_percentage"]])
Data_Frame_Data.append(inside)
In [56]:
Columns = ["Ground", "Country","Played","Won","Win_Percentage"]
Data_Frame_Data
Pitch_Team_Winnings = pd.DataFrame(Data_Frame_Data, columns=Columns)
In [57]:
Pitch_Team_Winnings.groupby(['Ground','Country']).mean()
Out[57]:
--> From the DataFrame above,¶
- We see that most of the matches at all the different venues were won by India and England.
- There are one or two other teams that pop out in the results but that is because the number of matches played for those cases are very less so the percentage is reflected as quite high for them.
- This gives us a good idea that England and India are the favourites for the World Cup 2019.
Analysis of total matches and the number of matches won, lost and tied¶
In [58]:
import numpy as np
import matplotlib.pyplot as plt
category_names = [ 'lost', 'aban', 'tied', 'won']
results = {
'Australia': [52.380952, 4.761905, 0, 23.809524],
'Bangladesh': [50.000000, 0, 0, 25.000000],
'England': [30.000000, 2.857143, 1.428571, 58.571429],
'India': [27.777778, 5.555556, 0, 66.666667],
'Newzealad': [50.000000, 0, 0, 35.714286],
'Pakistan': [61.111111, 0, 0, 27.777778],
'SouthAfrica':[60.000000,0,10.000000, 30.000000],
'SriLanka':[52.941176, 0, 5.882353, 35.294118],
'WestIndies':[62.500000, 0, 12.500000, 12.500000]
}
def survey(results, category_names):
labels = list(results.keys())
data = np.array(list(results.values()))
data_cum = data.cumsum(axis=1)
category_colors = plt.get_cmap('RdYlGn')(
np.linspace(0.15, 0.85, data.shape[1]))
fig, ax = plt.subplots(figsize=(9.2, 5))
ax.invert_yaxis()
ax.xaxis.set_visible(False)
ax.set_xlim(0, np.sum(data, axis=1).max())
for i, (colname, color) in enumerate(zip(category_names, category_colors)):
widths = data[:, i]
starts = data_cum[:, i] - widths
ax.barh(labels, widths, left=starts, height=0.5,
label=colname, color=color)
xcenters = starts + widths / 2
r, g, b, _ = color
text_color = 'white' if r * g * b < 0.5 else 'darkgrey'
for y, (x, c) in enumerate(zip(xcenters, widths)):
ax.text(x, y, str(int(c)), ha='center', va='center',
color=text_color)
ax.legend(ncol=len(category_names), bbox_to_anchor=(0, 1),
loc='lower left', fontsize='small')
return fig, ax
survey(results, category_names)
plt.title('Status & Number of matches/Team',loc = 'right')
plt.show()
Fig7.¶
--> The above graph shows that,¶
- in last few years Pakistan, West Indies and South Africa have not been performing well and so they have very less chance to win.
- Similarly, India and England have been doing very good and so they have more chances of winning more number of matches in the world cup
Also, as mentioned in Fig 2, we see that England and India are evenly matched teams. India performs slightly better based on the stats. But the fact that England will be playing at home, hence, gives them an edge over India.
However, this data alone is not enough to analyse the winner of the cup. We will now analyse player's data to draw some more conclusions.
Batsmen Data Analysis¶
In [59]:
Batsman = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/Batsman_Data.csv')
In [60]:
ground_Data = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/Ground_Averages.csv')
odi_Scores_Data = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ODI_Match_Totals.csv')
odi_Results_Data = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/ODI_Match_Results.csv')
wc_Players_Data = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/WC_players.csv')
bowler = pd.read_csv(r'/Users/Pushkar/UMD_Files/Sem1/Python/Project/Bowler_data.csv')
In [61]:
WC_venue_pitches = ["The Oval, London","Trent Bridge, Nottingham","Sophia Gardens, Cardiff","County Ground, Bristol","Rose Bowl, Southampton","County Ground, Taunton","Old Trafford, Manchester","Edgbaston, Birmingham","Headingley, Leeds","Lord's, London","Riverside Ground, Chester-le-Street"]
In [62]:
WC_Ground_Stats = []
ODI_Grounds = odi_Scores_Data.Ground
for i in ODI_Grounds:
for j in WC_venue_pitches:
if i in j:
#print("i ; ",i,"--j : ",j)
WC_Ground_Stats.append((i,j))
In [63]:
stadiums_data = [item[0] for item in set(WC_Ground_Stats)]
In [64]:
World_Cup_Grounds=["Lord's, London - England", "The Rose Bowl, Southampton - England", "Trent Bridge, Nottingham - England", "Sophia Gardens, Cardiff - England", "Kennington Oval, London - England", "Edgbaston, Birmingham - England", "Old Trafford, Manchester - England", "Riverside Ground, Chester-le-Street - England", "Headingley, Leeds - England", "County Ground, Bristol - England", "County Ground, Taunton - England"]
World_Cup_Grounds
Worldcup_Ground_Stats = []
England_Grounds = ground_Data.Ground
for grounds in England_Grounds:
for venues in World_Cup_Grounds :
if grounds in venues:
Worldcup_Ground_Stats.append((venues))
Worldcup_Ground_Stats
WorldCup_Grounds_Stats = ground_Data[ground_Data.Ground.isin([Ground for Ground in Worldcup_Ground_Stats])]
WorldCup_Grounds_Stats.head()
Out[64]:
--> The table above shows,¶
- all the stats for all the matches held at a particular venue in England.
- the Total number of matches played, the number of matches drawn, total number of runs scored on a partiular venue and so on.
This data can used to understand if a ground favours a bowler or a batsman. A low scoring ground is supposed to favour a bowler as not many runs are scored and a high scoring ground is supposed to favour the batsman.
Batsmen Performance In England - Analysis¶
In [65]:
Batsman.drop(columns=Batsman.columns[0],inplace=True)
Batsman = Batsman[~Batsman.Bat1.isin(["DNB","TDNB"])]
Batsman = Batsman[Batsman.Player_ID.isin(wc_Players_Data.ID)]
stadiums = [item[0] for item in set(WC_Ground_Stats)]
Batsman_in_England = Batsman[Batsman.Ground.isin(stadiums)]
Batsman_in_England.head()
Out[65]:
Computing averages of Batsmen on grounds in England¶
In [66]:
def Out_NotOut(value):
if "*" in value:
return 0
else:
return 1
Batsman_in_England["Out_NotOut"] = Batsman_in_England["Bat1"].apply(Out_NotOut)
#Batsman_in_England
In [67]:
Batsman_in_England["Runs"] = Batsman_in_England["Runs"].astype("int")
Batsman_in_England["BF"] = Batsman_in_England["BF"].astype("int")
Batsman_in_England["4s"] = Batsman_in_England["4s"].astype("int")
Batsman_in_England["6s"] = Batsman_in_England["6s"].astype("int")
In [68]:
Batsman_Data_Dummy = Batsman_in_England
Batsman_in_England = Batsman_in_England.groupby(["Ground","Batsman"]).sum().reset_index()
In [69]:
Batsman_in_England["Average"] = Batsman_in_England["Runs"]/Batsman_in_England.Out_NotOut
Batsman_in_England.head()
Out[69]:
--> The above dataframe describes the batsmen data.¶
Here we look at the averages and strike rates of the batsmen.There are other columns as well that contain the data about 4s and 6s the batsman hit and how many times he remained 'Not out' during his innings on these grounds.
- 4s: This shows the number of 4s scored. 4 runs are scored if the ball bounces before touching or going over the edge of the field.
- 6s: This shows the number of 6s scored. 6 runs if the ball does not bounce before passing over the boundary in the air.
- Average: A player's batting average is the total number of runs they have scored divided by the number of times they have been out.
- Strike Rate: Strike rate is a measure of how quickly a batsman scores runs.
In [70]:
Batsman_Data = Batsman_in_England.groupby(["Batsman"]).sum().reset_index()
Batsman_Data["Average"] = Batsman_Data["Runs"]/Batsman_Data["Out_NotOut"]
Batsman_Data.sort_values(by = "Average",ascending=False).sample(5)
Out[70]:
In [71]:
Batsman_Average_Best = Batsman_Data[(Batsman_Data.Out_NotOut>0) & (Batsman_Data.Average > 40 )].sort_values(by = "Average",ascending = False)
Batsman_Average_Best.head()
Out[71]:
In [72]:
Batsman_NoDuplicate = Batsman[["Player_ID","Batsman"]].drop_duplicates()
In [73]:
PlayerID = list(Batsman_Average_Best.merge(Batsman_NoDuplicate,how = "left",on = "Batsman")["Player_ID_y"].astype("int"))
Batsman_Average_Best["Player_ID"] = PlayerID
wc_Players_Data.columns = ["Player", "Player_ID","Country"]
Player_Country = list(Batsman_Average_Best.merge(wc_Players_Data,how = "left",on = "Player_ID")["Country"])
Batsman_Average_Best["Country"] = Player_Country
Batsman_Average_Best.head()
Out[73]:
Computing the Strike Rates for Batsmen¶
In [74]:
# Calculation for computing the Strike Rate
Batsman_Average_Best["Strike_Rate"] = Batsman_Average_Best["Runs"]/Batsman_Average_Best["BF"]*100
Batsman_Average_Best.head(10)
Out[74]:
In [75]:
Batsman_Average_Best.sort_values(["Strike_Rate"],ascending = False).head(10)
Out[75]:
--> Findings from data above:¶
- On the basis of Averages and Strike Rates, Batsmen from England dominate the strike rate department. Out of these English Batsmen, Johnny Bairstow and Jos Buttler have respectable averages as well.
- In the top ten Batsmen with High averages, there are many Indian Batsmen with a high averages. However that is mostly because of the less number of matches played by them as compared to Johnny Bairstow.
Hence looking at the data above, we think that England will have an advantage in the Batting department. Below, we will create a visualization representing this finding
Let's Visualize¶
In [76]:
import matplotlib.pyplot as plt
Pie_Batsmen = pd.DataFrame(Batsman_Average_Best["Country"].value_counts(), columns=["Country"])
Pie_Batsmen.index.name="Name"
plt.pie(Pie_Batsmen["Country"],labels=Pie_Batsmen.index,autopct='%1.1f%%')
plt.axis('equal')
plt.title('Percentage of Top Ranked Batsmen in a Team')
plt.show()
Fig8.¶
--> Here we see that,¶
- the maximum number of batsmen with high averages belong to England. It is normal to observe this as England are the host nation and they have played most of their matches in England only. However, Pakistan and India are close behind and are tied in the 2nd position.
- India and Pakistan are among the top ranked teams in the world and have batsmen who perform well in many different grounds around the world. From this data, we could conclude that England have the best Batsmen among the teams participating in the world as they have a Home Advantage.
Bowler's Data Analysis¶
In [77]:
# Filtering the bowlers data for the matches that were played in england
bowler = bowler[bowler.Ground.isin(stadiums)]
In [78]:
# Removing the rows from data where the overs is blank (-)
bowler = bowler[~bowler.Overs.str.contains('-')]
In [79]:
bowler.head()
Out[79]:
--> In the above DataFrame, the meaning of following column names is mentioned below:¶
- Econ: Economy - The runs that the bowler concedes in a single over (6 balls)
- Ave: Average - The runs that the bowler concedes per wicket
- Mdns: Maiden - The over where the bowler conceded 0 runs
- SR: Strike Rate - The number of balls bowled before the bowler got the wicket
In [80]:
# Total number of balls bowled by the bowler
def total_balls_bowled(value):
if "." in value:
over = value.split(".")
return int(over[0]) * 6 + int(over[1])
else:
return int(value) * 6
In [81]:
Ground_names = dict(set(WC_Ground_Stats))
def Full_Ground_names(value):
return Ground_names[value]
Ground_names
Out[81]:
In [82]:
# Sum of the bowler stats from all the matches played on all the grounds
bowler["Balls"] = bowler.Overs.apply(total_balls_bowled)
for i in ["Runs","Mdns","Wkts","Balls"]:
bowler[i] = bowler[i].astype("float")
Bowlers_in_England = bowler.groupby(["Bowler"]).sum()[["Runs","Mdns","Wkts","Balls"]].reset_index()
In [83]:
Bowlers_in_England.head()
Out[83]:
In [84]:
# From the sum above, we are now calculating the stats of a bowler for only the grounds in England
Bowlers_in_England["Economy"] = Bowlers_in_England.Runs * 6 /Bowlers_in_England.Balls
Bowlers_in_England["Average"] = Bowlers_in_England.Runs/ Bowlers_in_England.Wkts
Bowlers_in_England["Strike_Rate"] = Bowlers_in_England.Balls / Bowlers_in_England.Wkts
In [85]:
Bowlers_in_England.head()
Out[85]:
Since we want to look at the data of only the best bowlers in a team, we are removing the data of all the bowlers who have bowled less than 10 Overs in England. Also, we are deleting the records for the bowlers who have taken 0 wickets.
In [86]:
Bowlers_in_England = Bowlers_in_England[(Bowlers_in_England.Balls > 60) & (Bowlers_in_England.Wkts > 0)]
Bowlers_in_England.head()
Out[86]:
In [87]:
unique_bowler = bowler[['Player_ID','Bowler']].drop_duplicates()
Bowlers_in_England = Bowlers_in_England.merge(unique_bowler,how = "left",on = "Bowler")
wc_Players_Data.columns = ["Player", "Player_ID","Country"]
Country_Player = list(Bowlers_in_England.merge(wc_Players_Data,how = "left",on = "Player_ID")["Country"])
Bowlers_in_England["Country"] = Country_Player
Bowlers_in_England.iloc[55,-1] = "SriLanka"
In [88]:
Bowlers_in_England.head()
Out[88]:
--> We can say that the bowler with the highest number of maiden overs is a good bowler and has the potential to make his team win matches. So we find out the data for the top 10 bowlers with maiden overs¶
In [89]:
Bowlers_in_England.sort_values(by = ["Mdns"], ascending=False)[:10]
Out[89]:
--> In the above DataFrame,¶
- we can see the total number of maiden overs bowled by a bowler but this is not a true measure of a bowlers performance. This is because a bowler could have bowled 100 overs in total and out of those 10 could be maiden whereas some other bowler might have bowled 10 maiden overs out of a total of 50 overs.
- Thus we need to look at the percentage of the maiden overs bowled to truly understand the performance of the bowler.
In [90]:
Bowlers_in_England["Percentage_Of_Maiden_Overs"] = ((Bowlers_in_England.Mdns*6)/(Bowlers_in_England.Balls))*100
Bowlers_in_England.sort_values(by = ['Percentage_Of_Maiden_Overs'], ascending = False).head(10)
Out[90]:
--> The above table now gives us the Top 10 Bowlers based on Maidens bowled¶
In [91]:
Bowlers_in_England.sort_values(by = ["Average"], ascending = True).head(10)
Out[91]:
--> The above table gives us the Top 10 bowlers based on the 'Average'¶
In [92]:
Bowlers_in_England.sort_values(by = ["Economy"])[:10]
Out[92]:
--> The above table gives us the Top 10 Bowlers based on the 'Economy'¶
In [93]:
Bowlers_in_England.sort_values(by = ["Strike_Rate"])[:10]
Out[93]:
--> The above table gives us the Top 10 wicket taker bowlers¶
- Based on strike Rate
- The top 3 bowlers are fom India.
In [94]:
aggregations = {
'Runs':'sum',
'Mdns':'sum',
'Wkts':'sum',
'Balls':'sum',
'Economy': 'mean',
'Average':'mean',
'Strike_Rate':'mean',
'Percentage_Of_Maiden_Overs':'mean'
}
Bowlers_in_England_TeamWise_Data = Bowlers_in_England.groupby('Country').agg(aggregations).reset_index()
Bowlers_in_England_TeamWise_Data
Out[94]:
--> The above table represents the bowlers stats team wise¶
In [95]:
plt.figure(figsize=(15,10))
sns.boxplot(x = "Country", y = "Economy", data = Bowlers_in_England).set_title("Average Economy Rate - Team Wise")
Out[95]:
Fig9.¶
--> From the above Box Plot we observe that,¶
- teams like India, Australia and South Africa have low Economy rates. This means that these teams give away lesser runs in overs and hence are able to restrict other teams from scoring big runs, making it easier for these teams to defend their totals and confine opponent teams to a low runs total.
- England has an average bowling performance.
- West Indies are not at all consistent as there is a huge deviation in their Economy rates. Evident from the Box plot
In [96]:
plt.figure(figsize=(15,10))
sns.boxenplot(x = "Country", y = "Strike_Rate", data = Bowlers_in_England).set_title("Average Strike Rate - Team Wise")
Out[96]:
Fig10.¶
--> We observe that,¶
- Most of the teams take around 40 to 60 balls to take a wicket.
- New Zealand and South Africa are the most consistent teams when it comes to taking wickets.
- Bangladesh are not very good at taking wickets. Their average Strike Rate is around 75 balls and it varies from 25 to 170 balls. They are not very consistent when ot comes to bowling.
In [97]:
plt.figure(figsize=(15,8))
g = sns.lineplot( data = Bowlers_in_England_TeamWise_Data[["Economy","Percentage_Of_Maiden_Overs"]])
g.set_xticklabels(["Australia"]+[item for item in Bowlers_in_England_TeamWise_Data.Country])
plt.title('Comparison between Economy and Perc. Of Maiden Overs')
Out[97]:
Fig11.¶
--> The above line graph gives us the following details:¶
- Teams like India and South Africa have a good percentage of Maiden Overs bowled
- India and South Africa have low Economy rates. This means that these teams give away few Runs per Over and hence can restrict their opponents to low runs total
- South Africa seems to be the best team in terms of Bowling performance
Section4: Conclusion¶
In this analysis, we have focused on three different parameters to predict the outcome of the tournament. The analysis of the team, batsmen and bowler’s performance in the world cup venues (England in this case). These analyses gave us some insight into which team would have an edge in the tournament.
- Based on the venue, we could see that England had an edge on all the other teams as they had a huge Home Advantage. They were familiar with the pitches and the ground conditions whereas all the 'Away' teams had to adapt to the new conditions.
- We found out the top 10 batsmen from all the coutries and we could see that the the stats favoured the English Batsmen. Their Strike rate and Averages on the grounds in England were the highest. This meant that England had the best chances of scoring the maximum runs in a match.
- Also, on comparing the bowlers data on the basis of various factors like the Economy, Strike Rate and Average, we find out that even though the English bowlers are not the best in the world, there are players like 'Chris Woakes' that had a huge contribution in England's victory. He was among the top 5 bowlers who bowled the maximum numbers of maiden overs and also mantained a good Economy rate.
Based on the analysis above, we conclude that the home team 'England' is our pick of the lot.¶
Traditionally, this has always been the case that the host nation tends to start a tournament as favorites. The last two world cups had also been won by the host nation. The fact that the host nation plays maximum number of matches at their home gives them the edge as they are well verse with the conditions at play.
Our model will work true for any world cup in the future as well. We would just need to update the venue details in our data set and add the corresponding data about the teams and the venue to our data files.